package com.example.anpnovel.util;

import com.example.anpapi.entity.po.novelmodel.Chapter.Chapter;
import com.example.anpapi.entity.po.novelmodel.Chapter.ChapterStatus;
import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * TXT小说文件解析工具类
 * 支持多种章节识别模式：
 * 1. 序号格式：第1章、第一章、Chapter 1等
 * 2. 标题格式：以特定分隔符开头的行
 * 3. 分隔符格式：使用特定分隔符（如"=========="）分隔章节
 */
@Slf4j
public class TxtNovelParser {

    /**
     * 章节标题识别模式
     */
    private static final Pattern[] CHAPTER_PATTERNS = {
            // 第X章、第X节
            Pattern.compile("^第[零一二三四五六七八九十百千万\\d]+[章节卷集部回] "),
            // 数字序号：1. 2. 3. 或 01. 02. 03.
            Pattern.compile("^\\d+\\.\\s+"),
            // 中文序号：一、二、三、
            Pattern.compile("^[一二三四五六七八九十]+[、.]\\s*"),
//            // 特殊分隔符行（至少3个连续相同字符）
//            Pattern.compile("^[=*#-_]{3,}"),
    };

    /**
     * 解析TXT文件为章节列表
     *
     * @param filePath 文件路径
     * @param novelId  作品ID
     * @param volumeId 卷ID（可为null）
     * @return 章节列表
     */
    public static List<Chapter> parseFile(String filePath, Long novelId, Long volumeId) throws IOException {
        return parseFile(new File(filePath), novelId, volumeId);
    }

    /**
     * 解析TXT文件为章节列表
     *
     * @param file     文件对象
     * @param novelId  作品ID
     * @param volumeId 卷ID（可为null）
     * @return 章节列表
     */
    public static List<Chapter> parseFile(File file, Long novelId, Long volumeId) throws IOException {
        return parseFile(file, novelId, volumeId, Charset.forName("GBK"));
    }

    /**
     * 解析TXT文件为章节列表
     *
     * @param file     文件对象
     * @param novelId  作品ID
     * @param volumeId 卷ID（可为null）
     * @param charset  字符编码
     * @return 章节列表
     */
    public static List<Chapter> parseFile(File file, Long novelId, Long volumeId, Charset charset) throws IOException {
        List<String> lines = readFileLines(file, charset);
        return parseLines(lines, novelId, volumeId);
    }

    /**
     * 解析文本内容为章节列表
     *
     * @param content  文本内容
     * @param novelId  作品ID
     * @param volumeId 卷ID（可为null）
     * @return 章节列表
     */
    public static List<Chapter> parseContent(String content, Long novelId, Long volumeId) {
        String[] lines = content.split("\n");
        List<String> lineList = new ArrayList<>();
        for (String line : lines) {
            lineList.add(line);
        }
        return parseLines(lineList, novelId, volumeId);
    }

    /**
     * 读取文件所有行
     */
    private static List<String> readFileLines(File file, Charset charset) throws IOException {
        List<String> lines = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(new FileInputStream(file), charset))) {
            String line;
            while ((line = reader.readLine()) != null) {
                lines.add(line);
            }
        }
        return lines;
    }

    /**
     * 解析行列表为章节
     */
    private static List<Chapter> parseLines(List<String> lines, Long novelId, Long volumeId) {
        List<Chapter> chapters = new ArrayList<>();
        List<String> currentChapterLines = new ArrayList<>();
        String currentChapterTitle = null;
        int sortOrder = 1;

        for (int i = 0; i < lines.size(); i++) {
            String line = lines.get(i).trim();

            // 跳过空行（在章节开始前）
            if (line.isEmpty() && currentChapterTitle == null) {
                continue;
            }

            // 检查是否是章节标题
            if (isChapterTitle(line)) {
                // 如果已有章节，先保存
                if (currentChapterTitle != null && !currentChapterLines.isEmpty()) {
                    Chapter chapter = createChapter(
                            currentChapterTitle,
                            currentChapterLines,
                            novelId,
                            volumeId,
                            sortOrder++
                    );
                    chapters.add(chapter);
                }

                // 开始新章节
                currentChapterTitle = extractChapterTitle(line);
                currentChapterLines = new ArrayList<>();
            } else {
                // 如果还没有章节标题，跳过
                if (currentChapterTitle == null) {
                    continue;
                }
                // 添加到当前章节内容
                currentChapterLines.add(line);
            }
        }

        // 保存最后一个章节
        if (currentChapterTitle != null && !currentChapterLines.isEmpty()) {
            Chapter chapter = createChapter(
                    currentChapterTitle,
                    currentChapterLines,
                    novelId,
                    volumeId,
                    sortOrder
            );
            chapters.add(chapter);
        }

        // 如果没有识别到章节，将整个文件作为一章
        if (chapters.isEmpty() && !lines.isEmpty()) {
            String title = "第一章";
            List<String> contentLines = new ArrayList<>();
            for (String line : lines) {
                if (!line.trim().isEmpty()) {
                    contentLines.add(line.trim());
                }
            }
            if (!contentLines.isEmpty()) {
                Chapter chapter = createChapter(title, contentLines, novelId, volumeId, 1);
                chapters.add(chapter);
            }
        }

        log.info("解析完成，共识别到 {} 个章节", chapters.size());
        return chapters;
    }

    /**
     * 判断是否是章节标题
     */
    private static boolean isChapterTitle(String line) {
        if (line == null || line.trim().isEmpty()) {
            return false;
        }

        // 检查各种章节标题模式
        for (Pattern pattern : CHAPTER_PATTERNS) {
            Matcher matcher = pattern.matcher(line);
            if (matcher.find()) {
                return true;
            }
        }

        // 检查是否是分隔符行（至少3个连续相同字符，且长度较短，可能是分隔符）
        if (line.length() > 3 && line.length() < 50) {
            char firstChar = line.charAt(0);
            boolean allSame = true;
            for (int i = 1; i < line.length(); i++) {
                if (line.charAt(i) != firstChar) {
                    allSame = false;
                    break;
                }
            }
            if (allSame && (firstChar == '=' || firstChar == '-' || firstChar == '*' || firstChar == '#')) {
                return true;
            }
        }

        return false;
    }

    /**
     * 提取章节标题
     */
    private static String extractChapterTitle(String line) {
        line = line.trim();

        // 如果是分隔符行，返回默认标题
        if (line.matches("^[=*#-_]{3,}")) {
            return "章节";
        }

        // 移除常见的分隔符和装饰字符
        line = line.replaceAll("^[=*#-_\\s]+", "");
        line = line.replaceAll("[=*#-_\\s]+$", "");

        return line;
    }

    /**
     * 创建章节对象
     */
    private static Chapter createChapter(String title, List<String> contentLines, Long novelId, Long volumeId, int sortOrder) {
        // 合并内容行
        StringBuilder contentBuilder = new StringBuilder();
        for (String line : contentLines) {
            if (!line.trim().isEmpty()) {
                contentBuilder.append(line).append("\n");
            }
        }
        String content = contentBuilder.toString().trim();

        // 计算字数（中文字符数）
        int wordCount = countChineseCharacters(content);

        Chapter chapter = new Chapter();
        chapter.setNovelId(novelId);
        chapter.setVolumeId(volumeId);
        chapter.setTitle(title);
        chapter.setContent(content);
        chapter.setWordCount(wordCount);
        chapter.setSortOrder(sortOrder);
        chapter.setStatus(ChapterStatus.DRAFT); // 默认为草稿状态
        chapter.setIsFree(true);
        chapter.setReadCount(0);
        chapter.setLikeCount(0);
        chapter.setCommentCount(0);

        return chapter;
    }

    /**
     * 统计中文字符数（字数）
     */
    private static int countChineseCharacters(String text) {
        if (text == null || text.isEmpty()) {
            return 0;
        }
        int count = 0;
        for (char c : text.toCharArray()) {
            // 中文字符范围：\u4e00-\u9fa5
            if (c >= 0x4e00 && c <= 0x9fa5) {
                count++;
            } else if (!Character.isWhitespace(c) && c != '\n' && c != '\r') {
                // 非空白字符也计入（包括标点、数字、英文等）
                count++;
            }
        }
        return count;
    }
}

